Back to Main Menu

Asset Tools - (Assetic Python SDK)

Introduction

The Assetic Python SDK contains a set of tools that simplify common integration tasks for assets.  An asset is comprised of the asset record itself and within the asset are components.  Within each component are network measures (see also Asset Integration Overview).

The Asset Tools wrap this data structure into a single object representation "assetic.AssetToolsCompleteAssetRepresentation".  This allows all details of an asset to be prepared and passed to a single tool for complete asset creation or update.  This representation is also used when retrieving an asset via these tools.

Asset Tools Module

The Assetic Python SDK contains a module called assetic.AssetTools

 

Within that module are the following key methods:

  • get_complete_asset
  • create_complete_asset
  • update_complete_asset

 

AssetToolsCompleteAssetRepresentation

The Asset representation has the following structure:

  • asset_representation
    • an instance of "assetic.Assetic3IntegrationRepresentationsComplexAssetRepresentation"
  • components
    • a list array of "AssetToolsComponentRepresentation" instances

Within each "component" instance is:

  • component_representation
    • an instance of "assetic.Assetic3IntegrationRepresentationsComponentRepresentation"
  • dimensions
    • a list array of "Assetic3IntegrationRepresentationsComponentDimensionRepresentation"

Get Complete Asset

The following code sample gets an asset, including components and dimension details

 

  1. """
  2. Get an asset including component and dimensions using the SDK asset tools
  3. (Assetic.AssetsGetCompleteSDK.py)
  4. """
  5. import assetic
  6. #Assetic SDK instance
  7. asseticsdk=assetic.AsseticSDK("c:/users/you/assetic.ini",  None,"Info")
  8. #Tools API
  9. assettools = assetic.AssetTools()
  10.   
  11. assetid =  "411142055"
  12. attributes =  ["Zone","Comment"]
  13. asset = assettools.get_complete_asset(assetid,attributes)
  14. print(asset)
  15.   
  16.

Update Complete Asset

To simplify the update process, the Assetic Python SDK handles the complexity of all the core fields being updated.  The following code sample utilises the Assetic Python SDK tool "update_complete_asset".  This tool wraps the API endpoints for asset, component, and dimension creation.  It gets the current values for the asset, component, and dimension prior to the update and applies those values to fields that are NULL in the update object passed into this method.  The update object is an instance of "assetic.AssetToolsCompleteAssetRepresentation".  This object allows setting of the asset, component, and dimension values that are to be updated, values that are not to be updated are left as NULL in the object.

 

If only the asset is to be updated then the "assetic.AssetToolsComponentRepresentation" object within the "assetic.AssetToolsCompleteAssetRepresentation" instance is left as an empty array.  Likewise the dimension object within "assetic.AssetToolsComponentRepresentation" may be left as NULL if the component is to be updated but not the dimensions.

 

The following code sample updates an asset with components and dimensions. 

 

  1. """
  2. Update an asset, component and dimensions
  3. (Assetic.AssetsPutComplete.py)
  4. """
  5. import assetic
  6.   
  7. # Define location of configuration file, log file, log level
  8. asseticsdk=assetic.AsseticSDK("c:/users/you/assetic.ini",  None,  "Info")
  9. # Asset Tools API
  10. assettools = assetic.AssetTools()
  11.   
  12. def main(assetguid,componentguid,dimensionguid):
  13.   """
  14.     Update the asset, components, and component dimensions
  15.     """
  16.   
  17.   ##instantiate the complete asset representation
  18.     complete_asset_obj = assetic.AssetToolsCompleteAssetRepresentation()
  19.   
  20.   #create an instance of the complex asset object
  21.     asset = assetic.Assetic3IntegrationRepresentationsComplexAssetRepresentation()
  22.   ##set asset guid to update
  23.     asset.id = assetguid
  24.   ##set fields to update
  25.     asset.asset_external_identifier =  "upd"
  26.     attributes =  {"Comment":"a revised comment","Link":"www.assetic.com"}
  27.     asset.attributes = attributes
  28.   
  29.   ##Set the asset_representation to the defined asset values
  30.     complete_asset_obj.asset_representation = asset
  31.   
  32.   ##array list to put component plus dimensions
  33.     components_and_dims =  []
  34.   
  35.   #instantiate complete component representation
  36.     component_obj = assetic.AssetToolsComponentRepresentation()
  37.   
  38.   ##create an instance of the component representation
  39.     component = assetic.Assetic3IntegrationRepresentationsComponentRepresentation()
  40.     component.id = componentguid
  41.   ##set fields to update
  42.     component.design_life =  50
  43.     component_obj.component_representation = component
  44.   
  45.   ##create an array for the dimensions to be added to the component
  46.     dimlist =  []
  47.   
  48.   ##Create an instance of the dimension and set minimum fields
  49.     dim = assetic.Assetic3IntegrationRepresentationsComponentDimensionRepresentation()
  50.   #set the id fields
  51.     dim.id = dimensionguid
  52.     dim.component_id = componentguid
  53.   #set the field to update
  54.     dim.network_measure =  5
  55.   ##append to dimension array
  56.     dimlist.append(dim)
  57.   
  58.   ##Add the dimension array to the component
  59.     component_obj.dimensions = dimlist
  60.   
  61.   ##Add component to the list
  62.     components_and_dims.append(component_obj)
  63.   
  64.   ##add the component & dims array to the complete asset object
  65.     complete_asset_obj.components = components_and_dims
  66.   
  67.   ##update the complete asset
  68.     errcode = assettools.update_complete_asset(complete_asset_obj,False)
  69.   if errcode >  0:
  70.   return
  71.   print("success")
  72.   
  73. ##This will run the method main() to kickstart it all
  74. if __name__ ==  "__main__":
  75.   #set the IDs
  76.     assetguid =  "88439a40-6e1e-e711-946c-06edd62954d7"
  77.     componentguid =  "8e439a40-6e1e-e711-946c-06edd62954d7"
  78.     dimensionguid =  "90439a40-6e1e-e711-946c-06edd62954d7"
  79.   #execute the main function
  80.     main(assetguid,componentguid,dimensionguid)

Note that in the above sample there were updates to network measure, components, and the asset itself.

Create Asset

The following code sample utilises the Assetic Python SDK tool "create_complete_asset".  This tool wraps the API endpoints for asset, component, and dimension creation.

 

This code sample illustrates the creation of an asset, 2 components within that asset, and 2 dimension records within each component.

 

It utilises the "assetic.AssetToolsCompleteAssetRepresentation" object model to define the asset, components, and dimensions.  There are checks made to ensure the mandatory fields are not empty.

 

The response is the same object with the generated ID's included.

It is not mandatory for dimensions and components to be defined in the assetic.AssetToolsCompleteAssetRepresentation object.

 

  1. """
  2. Create an asset, component and dimensions
  3. (Assetic.AssetsPostComplete.py)
  4. """
  5. import assetic
  6. from datetime import datetime  #use to generate a unique asset id
  7.   
  8. # Assetic SDK instance
  9. asseticsdk=assetic.AsseticSDK("c:/users/you/assetic.ini",None,"Debug")
  10. #Asset Tools API
  11. assettools = assetic.AssetTools()
  12.   
  13. def main():
  14.   """
  15.     Create the asset, components, and component dimensions
  16.     Assumes the category does not have autonumber
  17.     """
  18.   ##generate an id based on the current time
  19.     dt = datetime.now()
  20.     assetid =  "{0}{1}{2}{3}{4}".format(
  21.         dt.month,dt.day,dt.hour,dt.minute,dt.second)
  22.   ##instantiate the complete asset representation
  23.     complete_asset_obj = assetic.AssetToolsCompleteAssetRepresentation()
  24.   
  25.   #create an instance of the complex asset object
  26.     asset = assetic.Assetic3IntegrationRepresentationsComplexAssetRepresentation()
  27.   ##mandatory fields
  28.     asset.asset_category="Roads"
  29.     asset.status =  "Active"
  30.     asset.asset_id = assetid
  31.     asset.asset_name =  "RD{0}".format(assetid)
  32.   
  33.     complete_asset_obj.asset_representation = asset
  34.   
  35.   ##array list to put component plus dimensions
  36.     components_and_dims =  []
  37.   
  38.   #instantiate complete component representation
  39.     component_obj = assetic.AssetToolsComponentRepresentation()
  40.   
  41.   ##create an instance of the component representation
  42.     component = assetic.Assetic3IntegrationRepresentationsComponentRepresentation()
  43.     componentname =  "{0}CMP1".format(assetid)
  44.     component.asset_id = assetid
  45.     component.label =  "Main Label"  #"Component Name in UI
  46.     component.component_type =  "Main"
  47.     component.dimension_unit =  "Metre"
  48.     component.network_measure_type =  "Length"
  49.   #optional fields
  50.     component.design_life =  50
  51.     component.external_identifier =  "Ext{0}".format(componentname)
  52.     component.material_type =  "Concrete"  #must exist
  53.   ##Add the component to the components
  54.     component_obj.component_representation = component
  55.   
  56.   ##create an array for the dimensions to be added to the component
  57.     dimlist =  []
  58.   
  59.   ##Create an instance of the dimension and set minimum fields
  60.     dim = assetic.Assetic3IntegrationRepresentationsComponentDimensionRepresentation()
  61.     dim.network_measure =  75.7
  62.     dim.unit =  "Metre"
  63.     dim.record_type =  "Info"  #could also be "Subtraction" or "Info"
  64.     dim.network_measure_type =  "Length"
  65.   ##can also include additional fields
  66.     dim.comments =  "Created via API"
  67.     dim.multiplier =  2.5  #will default as 1 if undefined
  68.     dimlist.append(dim)
  69.   
  70.   ##Create an instance of the dimension and set minimum fields
  71.     dim = assetic.Assetic3IntegrationRepresentationsComponentDimensionRepresentation()
  72.     dim.network_measure =  3
  73.     dim.unit =  "Metre"
  74.     dim.record_type =  "Subtraction"  #could also be "Subtraction" or "Info"
  75.     dim.network_measure_type =  "Length"
  76.   ##can also include additional fields
  77.     dim.comments =  "Created via API"
  78.     dim.multiplier =  1  #will default as 1 if undefined
  79.     dimlist.append(dim)
  80.   
  81.   ##Add the dimension array to the component
  82.     component_obj.dimensions = dimlist
  83.   
  84.   ##Add component to the list
  85.     components_and_dims.append(component_obj)
  86.   
  87.   #instantiate complete component representation
  88.     component_obj = assetic.AssetToolsComponentRepresentation()
  89.   
  90.   ##Create another component
  91.     componentname =  "{0}CMP2".format(assetid)
  92.     component = assetic.Assetic3IntegrationRepresentationsComponentRepresentation()
  93.     component.name = componentname
  94.     component.asset_id = assetid
  95.     component.label =  "Formation"
  96.     component.component_type =  "Formation"
  97.     component.dimension_unit =  "Metre"
  98.     component.network_measure_type =  "Length"
  99.   #optional fields
  100.     component.design_life =  50
  101.     component.external_identifier =  "Ext{0}".format(componentname)
  102.   #component.material_type = "Concrete"  #must exist
  103.     component_obj.component_representation = component
  104.   
  105.   ##create an array for the dimensions to be added to the component
  106.     dimlist =  []
  107.   
  108.   ##Create an instance of the dimension and set minimum fields
  109.     dim = assetic.Assetic3IntegrationRepresentationsComponentDimensionRepresentation()
  110.     dim.network_measure =  50
  111.     dim.component_id = componentname
  112.     dim.unit =  "Metre"
  113.     dim.record_type =  "Addition"  #could also be "Subtraction" or "Info"
  114.     dim.network_measure_type =  "Length"
  115.   ##can also include additional fields
  116.     dim.comments =  "Created via API"
  117.     dim.multiplier =  2  #will default as 1 if undefined
  118.     dimlist.append(dim)
  119.   
  120.   ##Create an instance of the dimension and set minimum fields
  121.     dim = assetic.Assetic3IntegrationRepresentationsComponentDimensionRepresentation()
  122.     dim.network_measure =  5
  123.     dim.component_id = componentname
  124.     dim.unit =  "Metre"
  125.     dim.record_type =  "Subtraction"  #could also be "Subtraction" or "Info"
  126.     dim.network_measure_type =  "Length"
  127.   ##can also include additional fields
  128.     dim.comments =  "Created via API"
  129.     dim.multiplier =  3  #will default as 1 if undefined
  130.     dimlist.append(dim)
  131.   
  132.   ##Add the dimension array to the component
  133.     component_obj.dimensions = dimlist
  134.   
  135.   ##Add component with dims to the list
  136.     components_and_dims.append(component_obj)
  137.   
  138.   ##add the component & dims array to the complete asset object
  139.     complete_asset_obj.components = components_and_dims
  140.   
  141.   ##create the complete asset
  142.     response = assettools.create_complete_asset(complete_asset_obj)
  143.   
  144.   if len(response.components)  >  0:
  145.   #get some ID's
  146.         assetguid = response.asset_representation.id
  147.   #first component
  148.         componentguid = response.components[0].component_representation.id
  149.   #first dimension
  150.         dimensionguid = response.components[0].dimensions[0].id
  151.   
  152. def create_asset(assetid,category,name,status):
  153.   """
  154.     Create an asset for the given asset ID and category
  155.     :param assetid: Assetic user friendly asset ID
  156.     :param assetid: asset category name
  157.     :param assetid: asset name
  158.     :param assetid: status - "Active" or "Pending"
  159.     :return: asset response object or None
  160.     """
  161.     asseticsdk.logger.info("Create the asset {0}".format(assetid))
  162.   
  163.   #create an instance of the complex asset object
  164.     asset = assetic.Assetic3IntegrationRepresentationsComplexAssetRepresentation()
  165.   ##mandatory fields
  166.     asset.asset_category=category
  167.     asset.status = status
  168.     asset.asset_id = assetid
  169.     asset.asset_name = name
  170.   
  171.   ##now execute the request
  172.   try:
  173.         newasset = assetapi.complex_asset_post(asset)
  174.   except assetic.rest.ApiException  as e:
  175.   if e.status ==  400:
  176.             msg =  "Bad Request. Status {0}, Reason: {1} {2}".format(
  177.                 e.status,e.reason,e.body)
  178.             asseticsdk.logger.error(msg)
  179.   else:
  180.             asseticsdk.logger.error("Status {0}, Reason: {1} {2}".format(
  181.                 e.status,e.reason,e.body))
  182.   return  None
  183.   return newasset
  184.   
  185. def create_component(assetid,componentname):
  186.   """
  187.     Create an component for the given asset ID and component name
  188.     :param assetid: Assetic component GUID or user friendly component ID
  189.     :param componentname: Assetic component name
  190.     :return: component response object or None
  191.     """
  192.     asseticsdk.logger.info("Create the component {0}".format(componentname))
  193.   
  194.   #create instance of component and set minimum values
  195.     component = assetic.Assetic3IntegrationRepresentationsComponentRepresentation()
  196.     component.name = componentname
  197.     component.asset_id = assetid
  198.     component.label =  "Main"
  199.     component.component_type =  "Main"
  200.     component.dimension_unit =  "Metre"
  201.     component.network_measure_type =  "Length"
  202.   #optional fields
  203.     component.design_life =  50
  204.     component.external_identifier =  "Ext{0}".format(componentname)
  205.     component.material_type =  "Concrete"  #must exist
  206.   
  207.   try:
  208.         component = componentapi.component_post(component)
  209.   except assetic.rest.ApiException  as e:
  210.   if e.status ==  400:
  211.             msg =  "Component for Component GUID {0} not found".format(assetguid)
  212.             asseticsdk.logger.error(msg)
  213.   else:
  214.             msg =  "Status {0}, Reason: {1} {2}".format(e.status,e.reason,e.body)
  215.             asseticsdk.logger.error(msg)
  216.   return  None
  217.   return component
  218.   
  219. def create_dimension(componentid,measure):
  220.   """
  221.     Create a dimension for the given component ID
  222.     :param assetid: Assetic component GUID or user friendly component ID
  223.     :param measure: The measure to apply to the dimension
  224.     :return: dimension response object or None
  225.     """
  226.     asseticsdk.logger.info("Create the dimensions for component {0}".format(
  227.         componentid))
  228.   
  229.   ##Create an instance of the dimension and set minimum fields
  230.     dim = assetic.Assetic3IntegrationRepresentationsComponentDimensionRepresentation()
  231.     dim.network_measure = measure
  232.     dim.unit =  "Metre"
  233.     dim.record_type =  "Addition"  #could also be "Subtraction" or "Info"
  234.     dim.network_measure_type =  "Length"
  235.   ##can also include additional fields
  236.     dim.comments =  "Created via API"
  237.     dim.multiplier =  2  #will default as 1 if undefined
  238.   
  239.   try:
  240.         newdim = componentapi.component_post_dimension(componentid,dim)
  241.   except assetic.rest.ApiException  as e:
  242.   if e.status ==  404:
  243.             msg =  "Dimensions for Component {0} not found".format(assetguid)
  244.             asseticsdk.logger.error(msg)
  245.   else:
  246.             msg =  "Status {0}, Reason: {1} {2}".format(e.status,e.reason,e.body)
  247.             asseticsdk.logger.error(msg)
  248.   return  None
  249.   return newdim
  250.   
  251. ##This will run the method main() to kickstart it all
  252. if __name__ ==  "__main__":
  253.     main()